/**
 * 
 */
package com.yidu.drug.service.impl;

import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;

import javax.annotation.Resource;

import org.aspectj.util.IStructureModel;
import org.springframework.stereotype.Service;

import com.yidu.drug.common.Page;
import com.yidu.drug.common.Tools;
import com.yidu.drug.dao.FdPoBreakdownModelMapper;
import com.yidu.drug.dao.InventoryModelMapper;
import com.yidu.drug.dao.InventoryRecordModelMapper;
import com.yidu.drug.dao.ProductionModelMapper;
import com.yidu.drug.dao.PurchaseOrderModelMapper;
import com.yidu.drug.dao.QtSumModelMapper;
import com.yidu.drug.dao.QualityTestingModelMapper;
import com.yidu.drug.dao.RepertoryModelMapper;
import com.yidu.drug.dao.ZgsSellDetailModelMapper;
import com.yidu.drug.dao.ZgsSellOrderModelMapper;
import com.yidu.drug.model.AuditModel;
import com.yidu.drug.model.FdPoBreakdownModel;
import com.yidu.drug.model.InventoryModel;
import com.yidu.drug.model.InventoryRecordModel;
import com.yidu.drug.model.ProductionModel;
import com.yidu.drug.model.PurchaseOrderModel;
import com.yidu.drug.model.QtSumModel;
import com.yidu.drug.model.QualityTestingModel;
import com.yidu.drug.model.RepertoryModel;
import com.yidu.drug.model.ZgsSellDetailModel;
import com.yidu.drug.model.ZgsSellOrderModel;
import com.yidu.drug.service.RepertoryService;

/**
 * 库存Service实现类
 * @author tanglei
 * @date 2018年8月20日 上午9:48:30
 * @version 1.0
 */
@Service
public class RepertoryServiceImpl implements RepertoryService{
	//注入库存Dao
	@Resource
	private RepertoryModelMapper repertoryDao;

	//采购Dao
	@Resource
	private PurchaseOrderModelMapper poDao;

	//分店采购订单明细Dao
	@Resource
	private FdPoBreakdownModelMapper fdPoBreakdownDao;
	
	//入库明细dao
	@Resource
	private InventoryModelMapper inventoryDao;

	//入库记录dao
	@Resource
	private InventoryRecordModelMapper inventoryRecordDao;

	//注入质检表Dao
	@Resource
	private QualityTestingModelMapper qualityTestingDao;
	
	//注入质检总报表Dao
	@Resource
	private QtSumModelMapper qtSumDao;
	
	//注入总公司销售订单Dao
	@Resource
	private ZgsSellOrderModelMapper zgsSellOrderModelDao;

	@Override
	public int deleteByPrimaryKey(String repId) {
		// TODO Auto-generated method stub
		return 0;
	}

	@Override
	public int insert(RepertoryModel record) {
		// TODO Auto-generated method stub
		return 0;
	}

	@Override
	public int insertSelective(RepertoryModel record) {
		// TODO Auto-generated method stub
		return 0;
	}

	@Override
	public RepertoryModel selectByPrimaryKey(String repId) {
		// TODO Auto-generated method stub
		return repertoryDao.selectByPrimaryKey(repId);
	}

	@Override
	public int updateByPrimaryKeySelective(RepertoryModel record) {
		// TODO Auto-generated method stub
		return 0;
	}

	@Override
	public int updateByPrimaryKey(RepertoryModel record) {
		// TODO Auto-generated method stub
		return 0;
	}

	@Override
	public int deleteByPwId(String pwId, Long repNumber) {
		// TODO Auto-generated method stub
		return 0;
	}

	/**
	 * 根据分公司ID查询库存数据
	 * @param repertory 传入一个库存对象
	 * @return 返回一个 map集合
	 */
	@Override
	public Map<String, Object> findAllDrugOrMaterials(RepertoryModel record) {
		//创建一个分页对象
		Page page = new Page();
		//给分页对象里面的页数属性赋值，数值为库存对象里面的页数数值
		page.setPage(Integer.valueOf(record.getPage()));
		//给分页对象里面的每页显示行数的属性赋值，数值为库存对象里面的每页显示行数数值
		page.setRows(Integer.valueOf(record.getLimit()));
		//给库存里面的分页对象属性赋值
		record.setPages(page);
		//创建一个map集合
		Map<String,Object> map = new HashMap<String,Object>();
		//创建一个list集合
		List<RepertoryModel> list = new ArrayList<RepertoryModel>();
		//定义一个count变量
		Long count = (long)0;
		//判断，判断是查询药品库存还是查询原材料库存
		if("drug".equals(record.getCondition())){
			//调用库存Dao里面的查询药品库存的方法
			list = repertoryDao.findByFileIdDrugRepertory(record);
			//调用库存Dao里面的查询药品库存总行数的方法
			count = repertoryDao.findDrugRepertoryRows(record);
		}else if("materials".equals(record.getCondition())){
			//调用库存Dao里面的查询原材料库存的方法
			list = repertoryDao.findByFileIdMaterialsRepertory(record);
			//调用库存Dao里面的查询原材料库存总行数的方法
			count = repertoryDao.findMaterialsRepertoryRows(record);
		}
		//给map集合赋值
		map.put("code", 0);
		map.put("msg", "");
		map.put("count", count);
		map.put("data", list);
		//返回map集合
		return map;
	}

	/**
	 * 根据分公司ID查询物品名称和物品类型
	 * @param repertory 传入一个库存对象
	 * @return 返回一个list集合
	 */
	@Override
	public List<RepertoryModel> findAllItemNameAndItemType(RepertoryModel record) {
		//创建一个list集合
		List<RepertoryModel> list = new ArrayList<RepertoryModel>();
		//判断，判断是查询药品名称，药品类型名称还是查询原材料名称，原材料类型名称
		if("drug".equals(record.getCondition())){
			//调用库存Dao里面的查询药品名称和药品类型名称的方法
			list = repertoryDao.findDrugNameAndDrugType(record);
		}else if("materials".equals(record.getCondition())){
			//调用库存Dao里面的查询原材料名称和原材料类型名称的方法
			list = repertoryDao.findMaterialsNameAndMaterialType(record);
		}
		//循环遍历集合,去重复
		for(int i=0;i<list.size();i++){
			for(int j=list.size()-1;j>i;j--){
				if(list.get(i).getItemType().equals(list.get(j).getItemType())){
					list.get(j).setItemType("");
				}
			}
		}
		//返回list集合
		return list;
	}

	@Override
	public RepertoryModel selectByFilId(String filId,String pwId) {
		// TODO Auto-generated method stub
		return repertoryDao.selectByFilId(filId,pwId);
	}

	@Override
	public void update(RepertoryModel repertory) {
		repertoryDao.updateByPrimaryKey(repertory);

	}

	/**
	 * 根据分公司id查询库存id
	 */
	@Override
	public String findById(String filId) {

		return repertoryDao.findById(filId);
	}

	/**
	 * 根据分公司id修改库存表数量
	 */
	@Override
	public Object updates(Long repNumber, String filId) {

		return repertoryDao.updates(repNumber, filId);
	}


	@Override
	public String insertById(QtSumModel qtSumModel) {
		//定义三个变量
		int rowsOne = 0;
		int rowsTwo = 0;
		int rowsThree = 0;
		int rowsFour = 0;
		//得到分公司ID
		String filId = qtSumModel.getFilId();
		//调用质检表Dao里面的根据质检总报表ID查询的方法
		List<QualityTestingModel> list = qualityTestingDao.selectByPrimaryKeyTwo(qtSumModel.getSumId());
		//循环遍历集合
		for(QualityTestingModel qualityTesting:list){
			System.out.println(qualityTesting+"================================>");
			//判断qualitytesting是否为null
			//if(qualityTesting != null){
				//通过的数量
				long adoptNum = qualityTesting.getQtSumnum() - qualityTesting.getNopassNum();
				//判断分公司ID和业务ID是否为空
				if(!Tools.isEmpty(qtSumModel.getFilId()) && !Tools.isEmpty(qualityTesting.getPwId())){
					//创建一个库存对象
					RepertoryModel repertory = new RepertoryModel();
					//给库存对象的分公司ID赋值
					repertory.setFilId(qtSumModel.getFilId());
					//给库存对象的业务ID赋值
					repertory.setPwId(qualityTesting.getPwId());
					//调用库存对象Dao里面的根据分公司ID和业务ID查询的方法
					RepertoryModel repertorys = repertoryDao.findByFilIdAndPwId(repertory);
					//创建一个库存对象
					RepertoryModel repertoryOne = new RepertoryModel();
					//创建一个库存明细对象
					InventoryModel inventory = new InventoryModel();
					//创建一个库存记录对象
					InventoryRecordModel inventoryRecord = new InventoryRecordModel();
					//判断该对象是否为null
					if(repertorys != null) {
						long repNumber = repertorys.getRepNumber() + adoptNum;
						//给库存对象的数量赋值赋值
						repertoryOne.setRepNumber(repNumber);
						//给库存对象的库存ID赋值
						repertoryOne.setRepId(repertorys.getRepId());
						//调用库存Dao里面的修改的方法
						rowsOne = repertoryDao.updateByPrimaryKeySelective(repertoryOne);
						
						//给库存明细对象里面的库存ID赋值
						inventory.setRepId(repertorys.getRepId());
					}else {
						//得到一个随机数
						String repId = Tools.getRandomUUID();
						//给库存对象的库存ID赋值
						repertoryOne.setRepId(repId);
						//给库存对象的分公司ID赋值
						repertoryOne.setFilId(filId);
						//给库存对象的库存数量赋值
						repertoryOne.setRepNumber(adoptNum);
						//给库存对象的是否有效赋值
						repertoryOne.setIsva(Tools.ISVA_YES);
						//给库存对象的业务ID赋值
						repertoryOne.setPwId(qualityTesting.getPwId());
						//调用库存Dao里面的增加的方法
						rowsOne = repertoryDao.insertSelective(repertoryOne);
						
						//给库存明细对象里面的库存ID赋值
						inventory.setRepId(repId);
					}
					//给库存明细ID赋值
					inventory.setInvId(Tools.getRandomUUID());
					//给库存明细对象里面的业务ID赋值
					inventory.setPwId(qualityTesting.getPwId());
					//给看库存明细对象里面的库存数量赋值
					inventory.setInvNumber(qualityTesting.getQtSumnum() - qualityTesting.getNopassNum());
					//给库存明细对象里面的是否有效赋值
					inventory.setIsva(Tools.ISVA_YES);
					//给库存明细对象里面的生产时间赋值
					inventory.setProDate(new Date());
					//判断分公司ID是否为1
					if(!"1".equals(filId)){
						//调用总公司Dao里面的根据总公司ID查询的方法
						ZgsSellOrderModel zgsSellOrder = zgsSellOrderModelDao.selectByPrimaryKey(qtSumModel.getPoId());
						//给库存明细对象里面的批次号赋值
						inventory.setNumbers(String.valueOf(zgsSellOrder.getSoNum()));
					}
					//调用库存明细Dao里面的增加的方法
					rowsTwo = inventoryDao.insertSelective(inventory);
					
					//给库存记录对象的库存记录ID赋值
					inventoryRecord.setIrId(Tools.getRandomUUID());
					//给库存记录对象的业务ID赋值
					inventoryRecord.setPwId(qtSumModel.getPoId());
					//给库存记录对象的数量赋值
					inventoryRecord.setMatNum((int)adoptNum);
					//给库存记录对象的记录类型赋值
					inventoryRecord.setIrType("质检入库");
					//给库存记录对象的是否有效赋值
					inventoryRecord.setIsva(Tools.ISVA_YES);
					//给库存记录对象的分公司ID赋值
					inventoryRecord.setFilId(filId);
					//调用库存记录Dao里面的增加的方法
					rowsThree = inventoryRecordDao.insertSelective(inventoryRecord);
					
					//判断分公司ID是否为1
					if(!"1".equals(filId)){
						//创建一个库存对象
						RepertoryModel repertoryTwo = new RepertoryModel();
						//给库存对象的分公司ID赋值
						repertoryTwo.setFilId("1");
						//给库存对象的业务ID赋值
						repertoryTwo.setPwId(qualityTesting.getPwId());
						//调用库存Dao里面的根据分公司ID和业务ID查询的方法
						RepertoryModel repertoryThree = repertoryDao.findByFilIdAndPwId(repertoryTwo);
						//得到减去后的数量
						long repNumbers = repertoryThree.getRepNumber() - adoptNum;
						//给库存对象里面的库存数量赋值
						repertoryTwo.setRepNumber(repNumbers);
						//调用库存Dao里面的根据分公司ID和业务ID修改库存数量的方法
						rowsFour = repertoryDao.updateFilIdAndPwId(repertoryTwo);
					}
				}
			}
			//判断分公司ID是否为1
			if(!"1".equals(filId)){
				//判断rowsOne、rowsTwo、rowsThree是否大于0
				if(rowsOne > 0 && rowsTwo > 0 && rowsThree > 0 && rowsFour > 0){
					//创建一个质检总报表对象
					QtSumModel qtSum = new QtSumModel();
					//给质检总报表对象的总报表ID赋值
					qtSum.setSumId(qtSumModel.getSumId());
					//给质检总报表对象的质检备注赋值
					qtSum.setSumRemark("已入库");
					//调用质检总报表Dao里面的修改的方法
					qtSumDao.updateByPrimaryKeySelective(qtSum);
					//返回一个ok字符串
					return "ok";
				}else {
					//返回一个no字符串
					return "no";
				}
			}else {
				//判断rowOne、rowsTwo是否大于0
				if(rowsOne > 0 && rowsThree > 0){
					
					//创建一个采购订单对象
					PurchaseOrderModel po = new PurchaseOrderModel();
					//给采购订单对象的采购订单ID赋值
					po.setPoId(qtSumModel.getPoId());
					//给采购订单对象的采购订单状态赋值
					po.setPoState("已审核,已采购,已提交,已质检,已入库");
					//调用采购订单Dao里面的修改的方法
					poDao.updateByPrimaryKeySelective(po);
					
					//创建一个质检总报表对象
					QtSumModel qtSum = new QtSumModel();
					//给质检总报表对象的总报表ID赋值
					qtSum.setSumId(qtSumModel.getSumId());
					//给质检总报表对象的质检备注赋值
					qtSum.setSumRemark("已入库");
					//调用质检总报表Dao里面的修改的方法
					qtSumDao.updateByPrimaryKeySelective(qtSum);
					
					//返回一个OK字符串
					return "ok";
				}else {
					//返回一个no字符串
					return "no";
				}
			}
		//}
		//return "no";
	}

	@Override
	public List<RepertoryModel> selectById(RepertoryModel record) {
		return repertoryDao.selectById(record);
	}

	@Override
	public String updateById(RepertoryModel record) {

		//定义rows 运行修改方法
		int rows = repertoryDao.updateById(record);
		//if判断rows>0时进入页面上的ok程序
		if(rows > 0){
			return "ok";
		}else {
			return "no";
		}

	}
	/**
	 * 王志伟根据业务ID查询库存
	 */
	@Override
	public RepertoryModel findByPwId(String pwId) {
		// TODO Auto-generated method stub
		return repertoryDao.findByPwId(pwId);
	}

	/**
	 * 根据分公司ID查询库存预警的个数
	 * @param filId 传入一个分公司ID
	 * @return 返回一个总个数
	 */
	@Override
	public Long findCount(String filId) {
		// 调用库存dao里面的查询库存预警的个数
		Long count = repertoryDao.findCount(filId);
		if(count == null){
			count = (long)0;
		}
		return count;
	}
	
	@Override
	public String updateByfilId(String filId) {
		int rows = repertoryDao.updateByfilId(filId);
		if(rows > 0){
			return "ok";
		}else {
			return "no";
		}
	}

	/**
	 * 根据分公司ID和业务Id查询库存id
	 */
	@Override
	public String findByFilIdPwId(String pwId, String filId) {
		
		return repertoryDao.findByFilIdPwId(pwId, filId);
	}

	/**
	 * 根据分公司ID和业务ID查询
	 */
	@Override
	public String findByFilIdAndPwId(AuditModel audit) {
		//调用采购订单详情Dao里面的根据采购单订单ID查询的方法
		List<FdPoBreakdownModel> list = fdPoBreakdownDao.findAllById(audit.getQwId());
		//判断list集合的大小是否为0
		if(list.size() != 0){
			for(FdPoBreakdownModel fdPoBreakdown : list){
				//创建一个库存对象
				RepertoryModel repertory = new RepertoryModel();
				//给库存对象的分公司ID赋值
				repertory.setFilId("1");
				//个库存对象的业务ID赋值
				repertory.setPwId(fdPoBreakdown.getDrugId());
				//调用库存Dao里面的根据分公司DI和业务ID查询的方法
				RepertoryModel repertorys = repertoryDao.findByFilIdAndPwId(repertory);
				//判断该对象是否为null
				if(repertorys != null){
					//判断库存数量是否小于入库数量
					if(repertorys.getRepNumber() < fdPoBreakdown.getFdItemNumber()){
						return "1";
					}else {
						return "ok";
					}
				}else{
					return "2";
				}
			}
		}else{
			return "3";
		}
		return "no";
	}
}